/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package manager;

import entities.Administrateur;
import entities.Client;
import java.util.Map;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import org.primefaces.model.SortOrder;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import session.GestionnaireDeCompteBancaire;
import entities.CompteCourant;
import entities.CompteEpargne;
import entities.OperationBancaire;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpSession;
import org.primefaces.model.LazyDataModel;

/**
 *
 * @author ALAOUI_Pierre_CYWIER
 */
@ManagedBean
@SessionScoped
public class CompteBancaireMBean {

    @EJB
    private GestionnaireDeCompteBancaire gestionnaireCB;
    private CompteCourant compteB;
    private List<CompteCourant> liste;
    private LazyDataModel myLazyDataModel;
    private Client client;
    String nom;
    String prenom;
    String adresse;
    String login;
    String password;
    double soldeCompte;
    Long id;
    double soldeCompteEpargne;
    double taux;
    private CompteEpargne compteEpargne;
    private boolean connected = false;
    private Administrateur administrateur;
    private Long idEmetteur;
    private Long idRecepteur;
    private String statutUtilisateur = "administrateur";
    private List<Client> listeClient;

    /** Creates a new instance of CompteBancaireMBean */
    public CompteBancaireMBean() {

        myLazyDataModel = new LazyDataModel<Client>() {

            List<Client> datasource;

            @Override
            public List<Client> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String, String> filters) {


                String sortO = "";
                if (sortOrder.equals(sortOrder.DESCENDING)) {
                    sortO = "DESC";
                } else {
                    sortO = "ASC";
                }

                listeClient = getClients(first, pageSize, sortField, sortO);
                List<Client> data = new ArrayList<Client>();
                //filter  
                for (Client client : listeClient) {
                    boolean match = true;

                    for (Iterator<String> it = filters.keySet().iterator(); it.hasNext();) {
                        try {
                            String filterProperty = it.next();
                            String filterValue = filters.get(filterProperty);
                            Field field = Client.class.getDeclaredField(filterProperty);
                            field.setAccessible(true);
                            String fieldValue = String.valueOf(field.get(client));

                            if (filterValue == null || fieldValue.startsWith(filterValue)) {
                                match = true;
                            } else {
                                match = false;
                                break;
                            }
                        } catch (Exception e) {
                            match = false;
                        }
                    }

                    if (match) {
                        data.add(client);
                    }
                }
                //sort  
                if (sortField != null) {
                    Collections.sort(data, new Sort(sortField, sortOrder));
                }

                //rowCount  
                int dataSize = data.size();
                this.setRowCount(dataSize);

                //paginate  
                if (dataSize > pageSize) {
                    try {
                        return datasource.subList(first, first + pageSize);
                    } catch (IndexOutOfBoundsException e) {
                        return datasource.subList(first, first + (dataSize % pageSize));
                    }
                } else {
                    return data;
                }

            }
        };
    }

    // retourne une liste de tous compte courant
    public List<CompteCourant> getAllCompte() {
        liste = gestionnaireCB.getAllComptes();
        if (liste == null) {
            creerCompteTest();
            liste = gestionnaireCB.getAllComptes();
        }

        return liste;
    }

    // retourne une liste de toutes opérations bancaires associes au compte courant
    public List<OperationBancaire> getAllOperation() {
        return (List) this.compteB.getOperations();
    }
    
    // retourne une liste de toutes opérations bancaires associes au compte epargne
    public List<OperationBancaire> getOperationCompteEpargne() {
        return (List) this.compteEpargne.getListeOperationsCE();
    }

    // pour un client donné on veut savoir ses comptes epargne
    public List<CompteEpargne> getCompteEpargneClient() {
        List liste = (List) this.client.getListeCompteEpargne();

        return liste;
    }

    // pour un client donné on veut savoir son compte courant
    public CompteCourant getAfficherCompteCourantClient(Client client) {

        return client.getCompteCourant();

    }

    public CompteCourant getAfficherCompteCourantClient() {

        Client client = gestionnaireCB.trouverClient(login, password);
        return client.getCompteCourant();

    }

    // on cree de comptes courant pr le test
    public void creerCompteTest() {
        gestionnaireCB.creerComptesTest();
    }

    public int getCount() {
        return gestionnaireCB.getCount();
    }

    /** permet d'avoir des comptes courant paginés ===> LAZY LOADING
    public LazyDataModel<CompteCourant> getListeClientsPagines() {
    myLazyDataModel.setRowCount(this.getCount());
    return myLazyDataModel;
    }
     **/
    // permet d'avoir des clients pagines
    public LazyDataModel<Client> getListeClientsPagines() {
        myLazyDataModel.setRowCount(this.getCount());
        return myLazyDataModel;
    }

    // permet d'avoir de détails sur un compte courant
    public CompteCourant getDetails() {
        return compteB;
    }
    
    
    public CompteEpargne getDetailsCompteEpargne()
    {
        return compteEpargne;
    }
    // permet d'avoir de détails sur un client
    public Client getDetailsClient() {
        return client;
    }

    public List<CompteCourant> getComptes(int start, int nbComptes) {
        if (liste == null) {
            creerCompteTest();
            liste = gestionnaireCB.getComptes(start, nbComptes);
        }
        return liste;
    }

    public List<Client> getClientPagine(int start, int nbComptes) {
        listeClient = gestionnaireCB.getClients(start, nbComptes);
        return listeClient;
    }

    public List<CompteCourant> getComptes(int start, int nbComptes, String sortField, String sortOrder) {
        liste = gestionnaireCB.getComptes(start, nbComptes, sortField, sortOrder);
        if (liste.isEmpty()) {
            creerCompteTest();
            liste = gestionnaireCB.getComptes(start, nbComptes, sortField, sortOrder);
        }
        return liste;
    }

    public List<Client> getClients(int start, int nbComptes, String sortField, String sortOrder) {
        listeClient = gestionnaireCB.getClients(start, nbComptes, sortField, sortOrder);
        return listeClient;
    }

    public void transfererArgent(CompteCourant emetteur, CompteCourant destinataire, String argent) {
        double argentt;
        try {
            argentt = Double.valueOf(argent);
        } catch (Exception e) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Vous n'avez pas rentré un montant valide !"));
            return;
        }
        if (emetteur == null || destinataire == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Erreur !", "Vous avez entré des id inexistantes, les comptes n'existent pas"));
        } else if (argentt < 0) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Erreur !", "La somme d'argent est négative !"));
        } else if (emetteur.getSoldeCompte() < argentt) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "L'emetteur " + " n'a pas assez d'argent sur son compte..."));
        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Le transfert d'argent a bien été pris en compte !"));
            gestionnaireCB.transfererArgent(emetteur, destinataire, argentt);
        }
    }

    public void supprimerCompte(CompteCourant compte) {
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Le compte a bien été supprimé !"));
        gestionnaireCB.supprimerCompte(compte);
    }

    // utilise
    public void supprimerClient(Client client) {
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Le client a bien été supprimé !"));
        gestionnaireCB.supprimerClient(client);
    }

    // utilise
    public void retirerArgent(CompteCourant compte, double soldeCompte) {
        double argentt;


        try {
            argentt = Double.valueOf(soldeCompte);
        } catch (Exception e) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Vous n'avez pas entré un montant valide !"));
            return;
        }



        if (argentt < 0) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Erreur !", "La somme d'argent est négative !"));
        } else if (compte.getSoldeCompte() < argentt) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "opération refusée solde insuffisant"));
        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Le compte a bien été débité de :" + argentt + " €"));
            gestionnaireCB.retirerArgent(compte, argentt);
        }
    }

    // utilise
    public void ajouterArgent(CompteCourant compte, double soldeCompte) {
        double argentt;
        try {
            argentt = Double.valueOf(soldeCompte);

        } catch (Exception e) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Vous n'avez pas entré un montant valide !"));
            return;
        }
        if (argentt < 0) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Erreur !", "La somme d'argent est négative !"));
        } else {
            this.compteB = compte;
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Le compte a bien été crédité de : " + argentt + " €"));
            gestionnaireCB.ajouterArgent(compte, argentt);
        }
    }

    // 
    public String showDetails(CompteCourant compte) {
        this.compteB = compte;
        return "ajout-retrait?faces-redirect=true&amp;includeViewParams=true";
    }

    public String detailsTransfert(CompteCourant compte) {
        this.compteB = compte;
        return "transfertArgent?faces-redirect=true&amp;includeViewParams=true";

    }

    // utilise
    public String showDetailsClient(Client notreClient) {
        this.client = notreClient;

        return "detailsClient?faces-redirect=true";
    }

    public String showDetailsCompteEpargne(CompteEpargne compteEpargne) {
        this.compteEpargne = compteEpargne;
        return "detailsCompteEpargne";
    }

    // cherche un comptCourant par l'id
    public CompteCourant getCompteCourantById(Long id) {

        if (gestionnaireCB.getCompteById(id) == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "L'identifiant du compte courant:    " + id + " n'existe pas!!"));
            return null;
        } else {
            compteB = gestionnaireCB.getCompteById(id);
        }

        return compteB;
    }

    public CompteEpargne getCompteEpargneByID(Long id) {

        compteEpargne = gestionnaireCB.getCompteEpargneById(id);

        return compteEpargne;
    }

    // utile
    public Client getFindClient(Long id) {
        if (gestionnaireCB.chercherClient(id) == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "L'identifiant client entré:   " + id + " n'existe pas!!"));
            return null;
        } else {
            client = gestionnaireCB.chercherClient(id);
        }
        return client;
    }

    public Client getFindClientParNomPrenom(String nom, String prenom) {
       
        
        try {
            client = gestionnaireCB.findClientParNomPrenom(nom, prenom);
        } catch (Exception e) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Client entré:   " + nom + " " + prenom + " n'existe pas!!"));
            return null;
        }
        
        return client;
    }

    // affiche toutes les operations lies a ce compte
    public String operationB(CompteCourant compte) {
        this.compteB = compte;
        return "detail-operations?faces-redirect=true&amp;includeViewParams=true";
    }
    
    
    
    // affiche toutes les operations lies au compte epargne
    
    public String operationCompteEpargne(CompteEpargne compteEpargne) {
        this.compteEpargne = compteEpargne;
        return "detailsOperationCptEpargne?faces-redirect=true&amp;includeViewParams=true";
    }

    
    // utilise
    public List<Client> getAfficherClientsBanque() {
        List<Client> listeClients = gestionnaireCB.afficherClients();
        return listeClients;
    }

    public Client getAfficherClientConnecte() {

        return gestionnaireCB.trouverClient(login, password);
    }

    // creation d'un nouveau compte courant, on l'associe a un client 
    public void creerCompteCourant() {


        if (nom.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Nom du client est vide !"));

        } else if (prenom.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Prenom du client est vide !"));


        } else if (adresse.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Adresse du client est vide !"));


        } else if (login.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Login du client est vide !"));


        } else if (password.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Password du client est vide !"));

        } else if (soldeCompte == 0) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Solde du client doit être positive !"));

        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Création du compte courant reussi!!"));
            gestionnaireCB.creerClient(nom, prenom, adresse, login, password, soldeCompte);

        }






    }

    /*** 
     * 
     * 
     * 
     *                  les getteurs &&& setteurs
     * 
     * 
     * 
     * 
     * */
    public double getSoldeCompte() {
        return soldeCompte;
    }

    public void setSoldeCompte(double soldeCompte) {
        this.soldeCompte = soldeCompte;
    }

    public String getAdresse() {
        return adresse;
    }

    public void setAdresse(String adresse) {
        this.adresse = adresse;
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public double getSoldeCompteEpargne() {
        return soldeCompteEpargne;
    }

    public void setSoldeCompteEpargne(double soldeCompteEpargne) {
        this.soldeCompteEpargne = soldeCompteEpargne;
    }

    public double getTaux() {
        return taux;
    }

    public void setTaux(double taux) {
        this.taux = taux;
    }

    public CompteEpargne getCompteEpargne() {
        return compteEpargne;
    }

    public void setCompteEpargne(CompteEpargne compteEpargne) {
        this.compteEpargne = compteEpargne;
    }

    public GestionnaireDeCompteBancaire getGestionnaireCB() {
        return gestionnaireCB;
    }

    public void setGestionnaireCB(GestionnaireDeCompteBancaire gestionnaireCB) {
        this.gestionnaireCB = gestionnaireCB;
    }

    public boolean isConnected() {
        return connected;
    }

    public void setConnected(boolean connected) {
        this.connected = connected;
    }

    public Administrateur getAdministrateur() {
        return administrateur;
    }

    public void setAdministrateur(Administrateur administrateur) {
        this.administrateur = administrateur;
    }

    public Long getIdEmetteur() {
        return idEmetteur;
    }

    public void setIdEmetteur(Long idEmetteur) {
        this.idEmetteur = idEmetteur;
    }

    public Long getIdRecepteur() {
        return idRecepteur;
    }

    public void setIdRecepteur(Long idRecepteur) {
        this.idRecepteur = idRecepteur;
    }

    public String getStatutUtilisateur() {
        return statutUtilisateur;
    }

    public void setStatutUtilisateur(String statutUtilisateur) {
        this.statutUtilisateur = statutUtilisateur;
    }

    public List<String> getListeStatusUtilisateur() {
        List<String> myList = new ArrayList<String>();
        myList.add("client");
        myList.add("administrateur");

        return myList;
    }

    /*********************
     * 
     * 
     * Cas du compte Epargne
     * 
     * 
     * *******************/
    /// cas de compteEpargne
    // utilise
    public List<CompteEpargne> getAfficherComptesEpargne() {



        List<CompteEpargne> l = gestionnaireCB.afficherListeCompteEpargne();

        return l;

    }

    // on associe un compte epargne a un client existant
    public void getAssocierCompteEpargneClient(Long id, double soldeCompteEpargne, double taux) {

        if (getFindClient(id) != null) {

            if (soldeCompteEpargne == 0) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Solde du compte doit être > 0 !"));

            } else if (taux == 0) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Taux du compte doit être > 0 !"));

            } else if (id == null || id.equals("")) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant du client  est vide !"));

            } else {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Création du compte epargne reussi!!"));

                gestionnaireCB.associerCompteEpargneClient(id, soldeCompteEpargne, taux);
            }
        }
    }

    public String donnerInfoClient() {
        return "reponseRechercheClient";
    }

    /// tout ce qu'il faut pour se logguer
    public String doConnect() {


        // on peuple la BD

        List<Administrateur> listeAdmin = gestionnaireCB.afficherAdministrateur();

        List<Client> listeClient = gestionnaireCB.afficherClients();

        String valeurRetour = "";

        if (listeAdmin.isEmpty() && listeClient.isEmpty()) {

            gestionnaireCB.creerComptesTest();
        }


        if (login.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Login est vide !"));
            return null;
        }

        if (password.equals("")) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Password est vide !"));
            return null;
        }


        // connexion a l'application dépend du statut de l'utilisateur
        // méthode getListeStatusUtilisateur() returne une liste de statut utilisateur possible

        if (statutUtilisateur.equals("administrateur")) {
            try {

                administrateur = gestionnaireCB.trouverAdministrateur(login, password);
                connected = true;
                valeurRetour = "index";


            } catch (Exception e) {

                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", " Administrateur : Combinaison login/password incorrect!!"));
                return null;
            }


        } else if (statutUtilisateur.equals("client")) {

            try {

                client = gestionnaireCB.trouverClient(login, password);
                connected = true;
                valeurRetour = "pageClient";


            } catch (Exception e) {

                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", " Client : Combinaison login/password incorrect!!"));
                return null;
            }

        }




        return valeurRetour;



    }

    // retourne un administrateur connecte
    public Administrateur getAfficherAdministrateurConnecte() {
        administrateur = gestionnaireCB.trouverAdministrateur(login, password);
        return administrateur;
    }

    public String doDeconnect() {
        FacesContext fc = FacesContext.getCurrentInstance();
        HttpSession session = (HttpSession) fc.getExternalContext().getSession(false);
        connected = false;
        session.invalidate();


        return "authentification";
    }

    // pr l'instant : transfert : compte courant --> compte epargne
    // on transfere l'argent des comptes de meme client
    public void getTransfererArgentClient(Long idEmetteur, Long idRecepteur, double soldeCompte) {

        if (idEmetteur == null || idRecepteur == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant du compte émetteur  est vide !"));
        }

        try {

            //on vérifie içi si les identifiants entrés ne sont pas ceux d'un autre client qui n'est pas connecté
            if ((idEmetteur != findClientByLoginPassword(login, password).getCompteCourant().getId()
                    && !(findClientByLoginPassword(login, password).getListeCompteEpargne().contains(getCompteEpargneByID(idEmetteur))))
                    || (idRecepteur != findClientByLoginPassword(login, password).getCompteCourant().getId()
                    && !(findClientByLoginPassword(login, password).getListeCompteEpargne().contains(getCompteEpargneByID(idRecepteur))))) {

                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant d'un des comptes (Emeteur/récepteur) incorrect !"));

            }


            if (idEmetteur == idRecepteur) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant incorrecte !"));
            }

            if (soldeCompte == 0.0) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Veuillez indiquer le solde à transferer !"));
            } else {
                gestionnaireCB.transfererArgentClient(idEmetteur, idRecepteur, soldeCompte);
            }
        } catch (Exception e) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "login/Password incorrecte !"));
        }
    }

// virement concerne que seulement les comptes courant des clients
    public void doVirement(Long idEmetteur, Long idRecepteur, double soldeCompte) {

        if ((getFindClient(idEmetteur) != null) && (getFindClient(idRecepteur) != null)) {

            CompteCourant cptCourant = getFindClient(idEmetteur).getCompteCourant();

            if (idEmetteur == null || idEmetteur.equals("")) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant du client émetteur de virement est vide !"));

            } else if (idRecepteur == null || idRecepteur.equals("")) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Identifiant du client récepteur de virement  est vide !"));

            } else if (soldeCompte > cptCourant.getSoldeCompte()) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Opération refusée solde insuffisant!"));

            } else if (idRecepteur == idEmetteur) {
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Veuillez choisir 2 clients differents!!"));


            } else {
                if (getFindClient(idEmetteur).getCompteCourant().getSoldeCompte() < soldeCompte) {
                    FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Fonds insuffisants !"));
                } else {
                    FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "", "Virement effectué!!"));
                    gestionnaireCB.effectuerVirement(idEmetteur, idRecepteur, soldeCompte);
                }



            }
        }
    }

    public Client findClientByLoginPassword(String login, String password) {
        if (gestionnaireCB.trouverClient(login, password) == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Client avec login :  " + login + " et  password :  " + password + " non trouvé!!!!"));
            return null;
        } else {
            client = gestionnaireCB.trouverClient(login, password);
        }
        return client;
    }

    public Administrateur findAmdinistrateurByLoginPassword(String login, String password) {
        if (gestionnaireCB.trouverAdministrateur(login, password) == null) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Administrateur avec login :  " + login + " et  password :  " + password + " non trouvé!!!!"));
            return null;
        } else {
            administrateur = gestionnaireCB.trouverAdministrateur(login, password);
        }
        return administrateur;
    }

    public Client getClient() {
        return client;
    }

    public CompteCourant getCompteB() {
        return compteB;
    }

    public List<CompteCourant> getListe() {
        return liste;
    }

    public List<Client> getListeClient() {
        return listeClient;
    }

    public LazyDataModel getMyLazyDataModel() {
        return myLazyDataModel;
    }
}
